package api

import (
	"bbs-go/internal/consts"
	"bbs-go/internal/models"
	"bbs-go/internal/pkg/errs"
	"fmt"
	"strconv"
	"strings"

	"github.com/kataras/iris/v12"
	"github.com/mlogclub/simple/web"
	"github.com/mlogclub/simple/web/params"

	"bbs-go/internal/services"
)

type ChatGroupsController struct {
	Ctx iris.Context
}

// 创建群组
func (c *ChatGroupsController) PostAdd() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	groupName := c.Ctx.PostValue("name")
	if groupName == "" {
		return web.JsonError(web.NewError(-1, "群名称不能为空"))
	}
	groupIntroduce := c.Ctx.PostValue("introduce")

	// 判断群名是否已经存在
	group, err := services.ChatGroupsService.FindByGroupName(groupName)
	if err != nil {
		return web.JsonError(err)
	}

	if group.Id > 0 {
		return web.JsonError(web.NewError(-1, "群名称已经存在"))
	}

	// 创建群
	err = services.ChatGroupsService.CreateGroup(&models.ChatGroups{
		Name:        groupName,
		Introduce:   groupIntroduce,
		CreatedId:   user.Id,
		CreatedName: user.Nickname,
	})
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 修改群信息
func (c *ChatGroupsController) PostUpdate() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupIdStr := c.Ctx.PostValue("id")
	if groupIdStr == "" {
		return web.JsonError(web.NewError(-1, "群Id不能为空"))
	}

	groupId, err := strconv.ParseInt(groupIdStr, 10, 64)
	if err != nil {
		return web.JsonError(web.NewError(-1, "群Id校验错误"))
	}

	groupName := c.Ctx.PostValue("name")
	if groupName == "" {
		return web.JsonError(web.NewError(-1, "群名称不能为空"))
	}
	groupIntroduce := c.Ctx.PostValue("introduce")

	// 判断群名是否已经存在
	group, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}

	if group.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	// 修改群信息
	err = services.ChatGroupsService.UpdateGroupBaseInfo(&models.ChatGroups{
		ModelBase: models.ModelBase{
			Id: groupId,
		},
		Name:        groupName,
		Introduce:   groupIntroduce,
		UpdatedId:   user.Id,
		UpdatedName: user.Nickname,
	})
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 修改头像
func (c *ChatGroupsController) PostUpdateAvatar() *web.JsonResult {
	groupIdStr := c.Ctx.PostValue("id")
	if groupIdStr == "" {
		return web.JsonError(web.NewError(-1, "群Id不能为空"))
	}

	groupId, err := strconv.ParseInt(groupIdStr, 10, 64)
	if err != nil {
		return web.JsonError(web.NewError(-1, "群Id校验错误"))
	}

	// 判断群名是否已经存在
	group, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}

	if group.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	avatar := strings.TrimSpace(params.FormValue(c.Ctx, "avatar"))
	if len(avatar) == 0 {
		return web.JsonErrorMsg("头像不能为空")
	}

	err = services.ChatGroupsService.UpdateGroupAvatar(group.Id, avatar)
	if err != nil {
		return web.JsonError(err)
	}
	return web.JsonSuccess()
}

// 群组列表
func (c *ChatGroupsController) GetList() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	list, err := services.ChatGroupsService.FindMyChatGroupsList(user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	return web.JsonData(list)
}

// 群组列表
func (c *ChatGroupsController) GetMembersList() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	groupId := c.Ctx.URLParamInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}
	// 验证当前用户是否在群组中
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}

	p := params.NewQueryParams(c.Ctx)
	p = p.PageByReq()
	res, err := services.ChatGroupsMembersService.GetChatGroupsMembersList(p.Paging, groupId)
	if err != nil {
		return web.JsonError(err)
	}

	for i := 0; i < len(res.List); i++ {
		res.List[i].RoleName = consts.ChatGroupsMembersRoleMap[res.List[i].RoleId]
	}

	return web.JsonData(&web.PageResult{Results: res.List, Page: res.Paging})
}

// 解散群
func (c *ChatGroupsController) DeleteDissolve() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupId := c.Ctx.PostValueInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}
	// 验证当前用户是否在群组中
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	if chatGroupsMembers.RoleId != consts.ChatGroupsMembersRoleId_3 {
		return web.JsonError(web.NewError(-1, "当前用户没有权限解散群组"))
	}

	err = services.ChatGroupsService.DissolveGroup(groupId)
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 群管理拉人进群
func (c *ChatGroupsController) PostInvite() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupId := c.Ctx.PostValueInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}

	friendId := c.Ctx.PostValueInt64Default("friendId", 0)
	if friendId <= 0 {
		return web.JsonError(web.NewError(-1, "好友Id不能为空"))
	}

	// 判断群Id是否存砸
	chatGroups, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroups.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	// 验证当前用户是否群主或管理员
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	if chatGroupsMembers.RoleId != consts.ChatGroupsMembersRoleId_3 && chatGroupsMembers.RoleId != consts.ChatGroupsMembersRoleId_2 {
		return web.JsonError(web.NewError(-1, "当前用户没有权限邀请人"))
	}

	// 判断是否是好友
	chatFriends, err := services.ChatFriendsService.GetChatFriendsByFriendId(user.Id, friendId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatFriends.Id == 0 {
		return web.JsonError(web.NewError(-1, "好友关系不存在"))
	}

	// 将好友添加到群组
	err = services.ChatGroupsMembersService.Add(chatGroups.Id, chatGroups.Name, friendId)
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 群管理员移除成员
func (c *ChatGroupsController) PostRemove() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupId := c.Ctx.PostValueInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}

	memberId := c.Ctx.PostValueInt64Default("memberId", 0)
	if memberId <= 0 {
		return web.JsonError(web.NewError(-1, "成员Id不能为空"))
	}

	if user.Id == memberId {
		return web.JsonError(web.NewError(-1, "不能移除自己"))
	}

	// 判断群Id是否存砸
	chatGroups, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroups.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	// 验证当前用户是否群主或管理员
	adminGroup, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if adminGroup.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}

	// 验证当前用户是否群主或管理员
	if adminGroup.RoleId != consts.ChatGroupsMembersRoleId_3 && adminGroup.RoleId != consts.ChatGroupsMembersRoleId_2 {
		return web.JsonError(web.NewError(-1, "当前用户没有权限邀请人"))
	}

	// 验证用户是否在群里
	chatGroupsMember, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, memberId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroupsMember.Id == 0 {
		return web.JsonError(web.NewError(-1, "该用户不在该群组中"))
	}

	if adminGroup.RoleId == consts.ChatGroupsMembersRoleId_2 && chatGroupsMember.RoleId != consts.ChatGroupsMembersRoleId_2 {
		return web.JsonError(web.NewError(-1, "群管理员不能移除管理员"))
	}

	// 将好友添加到群组
	err = services.ChatGroupsMembersService.Remove(chatGroups.Id, memberId)
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 修改群成员角色
func (c *ChatGroupsController) PutRole() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupId := c.Ctx.PostValueInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}

	memberId := c.Ctx.PostValueInt64Default("memberId", 0)
	if memberId <= 0 {
		return web.JsonError(web.NewError(-1, "成员Id不能为空"))
	}

	memberRoleId := c.Ctx.PostValueInt64Default("memberRoleId", 0)
	if memberRoleId <= 0 {
		return web.JsonError(web.NewError(-1, "成员角色Id不能为空"))
	}

	if memberRoleId != consts.ChatGroupsMembersRoleId_2 && memberRoleId != consts.ChatGroupsMembersRoleId_1 {
		return web.JsonError(web.NewError(-1, "群成员角色Id不正确"))
	}

	// 判断群Id是否存在
	chatGroups, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroups.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	// 验证当前用户是否群主或管理员
	adminGroup, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if adminGroup.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	if adminGroup.RoleId != consts.ChatGroupsMembersRoleId_3 && adminGroup.RoleId != consts.ChatGroupsMembersRoleId_2 {
		return web.JsonError(web.NewError(-1, "当前用户没有权限邀请人"))
	}

	// 验证用户是否在群里
	chatGroupsMember, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, memberId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroupsMember.Id == 0 {
		return web.JsonError(web.NewError(-1, "该用户不在该群组中"))
	}

	// 修改群组角色
	err = services.ChatGroupsMembersService.UpdateMeberRole(chatGroups.Id, memberId, memberRoleId)
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 主动退群
func (c *ChatGroupsController) DeleteExit() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}

	groupId := c.Ctx.PostValueInt64Default("groupId", 0)
	if groupId <= 0 {
		return web.JsonError(web.NewError(-1, "群组ID不能为空"))
	}

	// 判断群Id是否存在
	chatGroups, err := services.ChatGroupsService.FindByGroupId(groupId)
	if err != nil {
		return web.JsonError(err)
	}
	if chatGroups.Id == 0 {
		return web.JsonError(web.NewError(-1, "群组不存在"))
	}

	// 验证当前用户是否在群里面
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	if chatGroupsMembers.RoleId == consts.ChatGroupsMembersRoleId_3 {
		return web.JsonError(web.NewError(-1, "群主不能主动退群"))
	}

	// 将好友添加到群组
	err = services.ChatGroupsMembersService.Exit(chatGroupsMembers)
	if err != nil {
		return web.JsonError(err)
	}

	return web.JsonData(models.Result{
		Result: true,
	})
}

// 查询好友聊天记录
func (c *ChatGroupsController) GetRecord() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	groupId := c.Ctx.URLParamInt64Default("groupId", 0)
	if groupId == 0 {
		return web.JsonError(fmt.Errorf("群租不存在"))
	}
	// 验证当前用户是否在群里面
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	p := params.NewQueryParams(c.Ctx)
	p = p.PageByReq()
	res, err := services.ChatGroupsMessagesService.GetGroupMessageList(p.Paging, groupId)
	if err != nil {
		return web.JsonError(err)
	}
	return web.JsonData(&web.PageResult{Results: res.List, Page: res.Paging})
}

// 查询好友聊天记录最近三天50条聊天记录
func (c *ChatGroupsController) GetRecordLast() *web.JsonResult {
	user := services.UserTokenService.GetCurrent(c.Ctx)
	if user == nil {
		return web.JsonError(errs.NotLogin)
	}
	groupId := c.Ctx.URLParamInt64Default("groupId", 0)
	if groupId == 0 {
		return web.JsonError(fmt.Errorf("群租不存在"))
	}
	// 验证当前用户是否在群里面
	chatGroupsMembers, err := services.ChatGroupsMembersService.FindChatGroupsMembersByGroupUserId(groupId, user.Id)
	if err != nil {
		return web.JsonError(err)
	}
	// 判断当前是否在群组中
	if chatGroupsMembers.Id == 0 {
		return web.JsonError(web.NewError(-1, "当前用户不在该群组中"))
	}
	res, err := services.ChatGroupsMessagesService.GetRecentGroupMessageList(groupId)
	if err != nil {
		return web.JsonError(err)
	}
	//未读消息状态更新为已读
	services.ChatGroupsMembersUnreadMessageService.SetUnRead(int(groupId), int(user.Id), false)
	return web.JsonData(&web.PageResult{Results: res.List, Page: res.Paging})
}
